home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / pc / ARASAN_S.ZIP / ATTACKS.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-14  |  5.6 KB  |  272 lines
  1. // Copyright 1993 by Jon Dart.  All Rights Reserved.
  2.  
  3. #include "attacks.h"
  4. #include "bearing.h"
  5. #ifndef WINDOWS
  6. #include <iostream.h>
  7. #endif
  8.  
  9. void 
  10. Attacks::clear()
  11. {
  12.     for (int i = 0; i < 64; i++)
  13.     {
  14.     my_attacks[i][White].clear();
  15.     my_attacks[i][Black].clear();
  16.     }
  17. }
  18.  
  19. Attacks::Attacks()
  20. {
  21.     clear();
  22. }
  23.  
  24. unsigned 
  25. Attacks::pawn_attacks(const Square & sq, const ColorType side) const
  26. {
  27.     if (sq.OnBoard())
  28.     return my_attacks[sq][side].num_attacks(Piece::Pawn);
  29.     else
  30.     return 0;
  31. }
  32.  
  33. void 
  34. Attacks::compute_attacks(const Board & board, const ColorType side)
  35. // initial computation of attack info
  36. {
  37.     for (int i = 0; i < 16; i++)
  38.     {
  39.     Square sq(board.PiecePos(side, i));
  40.     if (!sq.IsInvalid())
  41.         add_attacks(board, sq, side);
  42.     }
  43. }
  44.  
  45. void 
  46. Attacks::add_attacks(const Board & board,
  47.              const Square & sq, const ColorType side)
  48. {
  49.     static Square squares[Bearing::MaxBearSq];
  50.     Piece source(board[sq]);
  51.     int n = Bearing::Attack_or_Defend(board, sq, squares);
  52.     for (int j = 0; j < n; j++)
  53.     {
  54.     Square sq2(squares[j]);
  55.     add_attack(sq2, source, side);
  56.     }
  57. }
  58.  
  59. static const int BishopInverseDirection[4] = { 3, 2, 1, 0 };
  60. static const int RookInverseDirection[4] = { 1, 0, 3, 2 };
  61.  
  62. void 
  63. Attacks::add_discovered_attacks(const Board & board,
  64.                   const Square & sq, const Square & dest_square)
  65. {
  66.     for (int i = 0; i < 4; i++)
  67.     {
  68.     const byte *data = RookSquares[sq] + (8*i);
  69.     Square sq2;
  70.     for (;;)
  71.     {
  72.         if (*data == 255 || (sq2 = *data++) == dest_square)
  73.         break;
  74.         Piece piece(board[sq2]);
  75.         if (!piece.IsEmpty())
  76.         {
  77.         if (piece.Type() == Piece::Rook ||
  78.             piece.Type() == Piece::Queen)
  79.         {
  80.             Square sq3;
  81.             const byte *data2 = 
  82.               RookSquares[sq] + (8*RookInverseDirection[i]);
  83.             for (;;)
  84.             {
  85.             if ((sq3 = *data2++) == 255)
  86.                break;
  87.             Piece piece3(board[sq3]);
  88.             if (piece3.IsEmpty())
  89.             {
  90.                 add_attack(sq3, piece, piece.Color());
  91.                 if (sq3 == dest_square)
  92.                 break;
  93.             } 
  94.             else
  95.             {
  96.                 add_attack(sq3, piece, piece.Color());
  97.                 break;
  98.             }
  99.             }
  100.         }
  101.         break;
  102.         }
  103.     }
  104.     data = BishopSquares[sq] + (8*i);
  105.     sq2 = sq;
  106.     for (;;)
  107.     {
  108.         if (*data == 255 || (sq2 = *data++) == dest_square)
  109.         break;
  110.         Piece piece(board[sq2]);
  111.         if (!piece.IsEmpty())
  112.         {
  113.         if (piece.Type() == Piece::Queen ||
  114.             piece.Type() == Piece::Bishop)
  115.         {
  116.             Square sq3;
  117.             const byte *data2 = 
  118.               BishopSquares[sq] + (8*BishopInverseDirection[i]);
  119.             for (;;)
  120.             {
  121.             if ((sq3 = *data2++) == 255)
  122.                break;
  123.             Piece piece3(board[sq3]);
  124.             if (piece3.IsEmpty())
  125.             {
  126.                 add_attack(sq3, piece, piece.Color());
  127.                 if (sq3 == dest_square)
  128.                 break;
  129.             } 
  130.             else
  131.             {
  132.                 add_attack(sq3, piece, piece.Color());
  133.                 break;
  134.             }
  135.             }
  136.         }
  137.         break;
  138.         }
  139.     }
  140.     }
  141. }
  142.  
  143. void 
  144. Attacks::remove_attacks(const Board & board,
  145.             const Square & sq, const ColorType side)
  146. {
  147.     static Square squares[Bearing::MaxBearSq];
  148.     Piece source(board[sq]);
  149.     int n = Bearing::Attack_or_Defend(board, sq, squares);
  150.     for (int j = 0; j < n; j++)
  151.     {
  152.     Square sq2(squares[j]);
  153.     remove_attack(sq2, source, side);
  154.     }
  155. }
  156.  
  157. void 
  158. Attacks::remove_discovered_attacks(const Board & board,
  159.                  const Square & sq, const Square & start_square)
  160. {
  161.     for (int i = 0; i < 4; i++)
  162.     {
  163.     Square sq2(sq);
  164.     const byte *data = RookSquares[sq] + (8*i);
  165.     for (;;)
  166.     {
  167.         if (*data == 255 || (sq2 = *data++) == start_square)
  168.         break;
  169.         Piece piece(board[sq2]);
  170.         if (!piece.IsEmpty())
  171.         {
  172.         if (piece.Type() == Piece::Rook ||
  173.             piece.Type() == Piece::Queen)
  174.         {
  175.             const byte *data2 = 
  176.               RookSquares[sq] + (8*RookInverseDirection[i]);
  177.             Square sq3(sq);
  178.             for (;;)
  179.             {
  180.             if ((sq3 = *data2++) == 255)
  181.                break;
  182.             else if (sq3 == start_square)
  183.             {
  184.                 remove_attack(sq3, piece, piece.Color());
  185.                 break;
  186.             }
  187.             Piece piece3(board[sq3]);
  188.             if (piece3.IsEmpty())
  189.                 remove_attack(sq3, piece, piece.Color());
  190.             else
  191.             {
  192.                 remove_attack(sq3, piece, piece.Color());
  193.                 break;
  194.             }
  195.             }
  196.         }
  197.         break;
  198.         }
  199.     }
  200.     sq2 = sq;
  201.     data = BishopSquares[sq] + (8*i);
  202.     for (;;)
  203.     {
  204.         if (*data == 255 || (sq2 = *data++) == start_square)
  205.         break;
  206.         Piece piece(board[sq2]);
  207.         if (!piece.IsEmpty())
  208.         {
  209.         if (piece.Type() == Piece::Queen ||
  210.             piece.Type() == Piece::Bishop)
  211.         {
  212.             Square sq3;
  213.             const byte *data2 = 
  214.                 BishopSquares[sq] + (8*BishopInverseDirection[i]);
  215.             for (;;)
  216.             {
  217.             if ((sq3 = *data2++) == 255)
  218.                 break;
  219.             else if (sq3 == start_square)
  220.             {
  221.                 remove_attack(sq3, piece, piece.Color());
  222.                 break;
  223.             }
  224.             Piece piece3(board[sq3]);
  225.             if (piece3.IsEmpty())
  226.                 remove_attack(sq3, piece, piece.Color());
  227.             else
  228.             {
  229.                 remove_attack(sq3, piece, piece.Color());
  230.                 break;
  231.             }
  232.             }
  233.         }
  234.         break;
  235.         }
  236.     }
  237.     }
  238. }
  239.  
  240. #if !defined(WINDOWS) && defined(DEBUG_ATTACKS)
  241. void 
  242. Attacks::dump_attacks()
  243. {
  244.     int i;
  245.     int j;
  246.     for (i = 0; i < 8; i++)
  247.     {
  248.     for (j = 0; j < 8; j++)
  249.     {
  250.         Square sq(j + 1, i + 1, Black);
  251.         cout << " [" << my_attacks[sq][White] << "," << 
  252.                 my_attacks[sq][Black] << "]";
  253.     }
  254.     cout << endl;
  255.     }
  256. }
  257. #endif
  258.  
  259. #ifdef DEBUG_ATTACKS
  260. int Attacks::operator == (const Attacks &a) const
  261. {
  262.     for (int i = 0; i < 64; ++i)
  263.     {
  264.         if (my_attacks[i][White] != a.my_attacks[i][White])
  265.         return False;
  266.         if (my_attacks[i][Black] != a.my_attacks[i][Black])
  267.         return False;
  268.     }
  269.     return True;
  270. }
  271. #endif
  272.